/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.cip.esymons.tesoreria.beans;

import org.cip.esymons.general.util.ControladorAbstracto;
import cip.util.PaginacionFiltro;
import org.cip.esymons.tesoreria.adapters.KeyCI;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

import javax.faces.model.SelectItem;
import org.cip.esymons.eventos.be.Evento;
import org.cip.esymons.tesoreria.bc.CuentaIngresoAmbienteDelegate;
import org.cip.esymons.tesoreria.bc.CuentaIngresoDelegate;
import org.cip.esymons.tesoreria.bc.CuentaIngresoElectoralDelegate;
import org.cip.esymons.tesoreria.bc.CuentaIngresoEventoDelegate;
import org.cip.esymons.tesoreria.bc.CuentaIngresoOrdinarioVitalicioDelegate;
import org.cip.esymons.tesoreria.bc.CuentaIngresoServicioDelegate;
import org.cip.esymons.tesoreria.bc.EventoDelegate;
import org.cip.esymons.tesoreria.be.CuentaContable;
import org.cip.esymons.tesoreria.be.CuentaIngreso;
import org.cip.esymons.tesoreria.be.CuentaIngresoElectoral;
import org.cip.esymons.tesoreria.be.CuentaingresoAmbiente;
import org.cip.esymons.tesoreria.be.CuentaingresoEvento;
import org.cip.esymons.tesoreria.be.CuentaingresoOrdinariovitalicio;
import org.cip.esymons.tesoreria.be.CuentaingresoServicio;
import org.cip.esymons.tesoreria.be.EnumAplicableCI;
import org.cip.esymons.tesoreria.be.EnumEstadoCuentaIngreso;
import org.cip.esymons.tesoreria.be.EnumTipoCuentaIngreso;
import org.cip.esymons.tesoreria.be.EnumTipoDescuento;
import org.cip.esymons.tesoreria.be.EnumTipoMulta;
import org.richfaces.component.html.HtmlTree;
import org.richfaces.event.NodeSelectedEvent;
import org.richfaces.model.TreeNode;
import org.richfaces.model.TreeNodeImpl;

/**
 *
 * @author Gilmar Montoya
 */
public class CuentaIngresoController extends ControladorAbstracto {

    private CuentaIngresoDelegate delegado;
    private CuentaIngresoEventoDelegate delegadoEvento;
    private CuentaIngresoAmbienteDelegate delegadoAmbiente;
    private CuentaIngresoServicioDelegate delegadoServicio;
    private CuentaIngresoElectoralDelegate delegadoProcesoElectoral;
    private CuentaIngreso cuentaIngresoSeleccionado;
    private CuentaIngreso cuentaIngreso;
    //nuevo
    private CuentaIngresoOrdinarioVitalicioDelegate delegadoCuentaIngresoOrdinarioVitalicio;
    private CuentaingresoEvento cuentaingresoEvento;
    private CuentaIngresoElectoral cuentaIngresoElectoral;
    private CuentaingresoAmbiente cuentaingresoAmbiente;
    private CuentaingresoServicio cuentaingresoServicio;
    private String tipoCuentaEditar = "";
    private int tipoAplicableAntiguo;
    //fin nuevo
    private boolean actualizar;
    private int padreHijo;//0=padre;1=hijo
    private TreeNode nodePrincipal = null;
    private TreeNode currentNode = null;
    private String nombreCuentaContable;
    private MiPaginador paginador;
    private int controladorSolicitante = 0;//sirve para saber de donde se le esta llamando (que controlador lo llama "ProcesoElectoralController")
    private Date fechaInicio;
    //lizardo estuvo aqui
    private Integer eveCodigo;

    public CuentaIngresoController() {
        delegadoCuentaIngresoOrdinarioVitalicio = new CuentaIngresoOrdinarioVitalicioDelegate();
        delegado = new CuentaIngresoDelegate();
        delegadoEvento = new CuentaIngresoEventoDelegate();
        delegadoServicio = new CuentaIngresoServicioDelegate();
        delegadoAmbiente = new CuentaIngresoAmbienteDelegate();
        delegadoProcesoElectoral = new CuentaIngresoElectoralDelegate();
        actualizar = true;
        paginador = new MiPaginador(null, 20);
        paginador.setFilter("");
        //lizardo estuvo aqui
        eveCodigo = 0;
    }

    //lizardo estuvo aqui
    public Integer getEveCodigo() {
        return eveCodigo;
    }

    //lizardo estuvo aqui
    public void setEveCodigo(Integer eveCodigo) {
        this.eveCodigo = eveCodigo;
    }

    /**
     * @return the paginador
     */
    public MiPaginador getPaginador() {
        return paginador;
    }

    /**
     * @param paginador the paginador to set
     */
    public void setPaginador(MiPaginador paginador) {
        this.paginador = paginador;
    }

    /**
     * @return the controladorSolicitante
     */
    public int getControladorSolicitante() {
        return controladorSolicitante;
    }

    /**
     * @param controladorSolicitante the controladorSolicitante to set
     */
    public void setControladorSolicitante(int controladorSolicitante) {
        this.controladorSolicitante = controladorSolicitante;
    }

    /**
     * @return the cuentaingresoEvento
     */
    public CuentaingresoEvento getCuentaingresoEvento() {
        return cuentaingresoEvento;
    }

    /**
     * @param cuentaingresoEvento the cuentaingresoEvento to set
     */
    public void setCuentaingresoEvento(CuentaingresoEvento cuentaingresoEvento) {
        this.cuentaingresoEvento = cuentaingresoEvento;
    }

    /**
     * @return the cuentaIngresoElectoral
     */
    public CuentaIngresoElectoral getCuentaIngresoElectoral() {
        return cuentaIngresoElectoral;
    }

    /**
     * @param cuentaIngresoElectoral the cuentaIngresoElectoral to set
     */
    public void setCuentaIngresoElectoral(CuentaIngresoElectoral cuentaIngresoElectoral) {
        this.cuentaIngresoElectoral = cuentaIngresoElectoral;
    }

    /**
     * @return the cuentaingresoAmbiente
     */
    public CuentaingresoAmbiente getCuentaingresoAmbiente() {
        return cuentaingresoAmbiente;
    }

    /**
     * @param cuentaingresoAmbiente the cuentaingresoAmbiente to set
     */
    public void setCuentaingresoAmbiente(CuentaingresoAmbiente cuentaingresoAmbiente) {
        this.cuentaingresoAmbiente = cuentaingresoAmbiente;
    }

    /**
     * @return the cuentaingresoServicio
     */
    public CuentaingresoServicio getCuentaingresoServicio() {
        return cuentaingresoServicio;
    }

    /**
     * @param cuentaingresoServicio the cuentaingresoServicio to set
     */
    public void setCuentaingresoServicio(CuentaingresoServicio cuentaingresoServicio) {
        this.cuentaingresoServicio = cuentaingresoServicio;
    }

    /**
     * @return the fechaInicio
     */
    public Date getFechaInicio() {
        return fechaInicio;
    }

    /**
     * @param fechaInicio the fechaInicio to set
     */
    public void setFechaInicio(Date fechaInicio) {
        this.fechaInicio = fechaInicio;
    }

    /**
     * @return the padreHijo
     */
    public int getPadreHijo() {
        return padreHijo;
    }

    /**
     * @param padreHijo the padreHijo to set
     */
    public void setPadreHijo(int padreHijo) {
        this.padreHijo = padreHijo;
    }
    //Paginador para cuentas anuladas y Inactivas

    public final class MiPaginador<k> extends PaginacionFiltro {

        private String descripcion = null;
        private String codigo = null;

        public MiPaginador(String page, int quantity) {
            super(page, quantity);
        }

        @Override
        public int contar() throws Exception {
            try {
                return delegado.contarCuentasIngresoAnuladaseInactivas(descripcion, codigo);
            } catch (Exception ex) {
                System.out.println("Error contar:" + ex.getMessage());
                return 0;
            }
        }

        @Override
        public List listar() throws Exception {
            try {
                return delegado.cuentasIngresoAnuladaseInactivas(paginador.getCantidadxPagina(), paginador.getPosicion(), descripcion, codigo);
            } catch (Exception ex) {
                System.out.println("Error Listar:" + ex.getMessage());
                return new ArrayList();
            }
        }

        public String getDescripcion() {
            return descripcion;
        }

        public void setDescripcion(String valor) {
            try {
                if (!valor.equals(descripcion)) {
                    descripcion = valor;
                    reset();
                }
            } catch (Exception ex) {
                descripcion = null;
            }
        }

        public String getCodigo() {
            return codigo;
        }

        public void setCodigo(String valor) {
            try {
                if (!valor.equals(codigo)) {
                    codigo = valor;
                    reset();
                }
            } catch (Exception ex) {
                codigo = null;
            }
        }
    }
    //Fin Paginador para cuentas anuladas y Inactivas
    //arbol 

    private void addNodes(TreeNode node, CuentaIngreso padre) {
        List<CuentaIngreso> lista = new ArrayList();
        if (padre == null) {
            lista = delegado.cuentasIngresoPadre();
        } else {
            lista = delegado.cuentasIngresoHijo(padre);
        }
        if (lista != null) {
            for (CuentaIngreso ci : lista) {
                KeyCI key = new KeyCI();
                TreeNodeImpl nodeImpl = new TreeNodeImpl();
                key.setKey(ci.getCinCodigo());
                key.setDescripcion(ci.getCinDesc());
                if (padre == null) {
                    key.setTipo("padre");
                } else {
                    key.setTipo("hijo");
                }
                nodeImpl.setData(key);
                node.addChild(key, nodeImpl);
                addNodes(nodeImpl, ci);
            }
        }
    }

    private TreeNode loadTree() {
        try {
            TreeNode rootNode = null;
            rootNode = new TreeNodeImpl();
            addNodes(rootNode, null);
            return rootNode;
        } catch (Exception e) {
            return null;
        }
    }

    public void processSelection(NodeSelectedEvent event) {
        try {
            HtmlTree tree = (HtmlTree) event.getComponent();
            currentNode = tree.getModelTreeNode(tree.getRowKey());
            String codigo = ((KeyCI) currentNode.getData()).getKey();
            cuentaIngresoSeleccionado = delegado.find(codigo);
        } catch (Exception ex) {
            System.out.println("Error" + ex.getMessage());
        }
    }

    public TreeNode getTreeNode() {
        if (actualizar) {
            nodePrincipal = loadTree();
            actualizar = false;
        }
        return nodePrincipal;
    }

    /**
     * @return the cuentaIngreso
     */
    public CuentaIngreso getCuentaIngreso() {
        return cuentaIngreso;
    }

    /**
     * @param cuentaIngreso the cuentaIngreso to set
     */
    public void setCuentaIngreso(CuentaIngreso cuentaIngreso) {
        this.cuentaIngreso = cuentaIngreso;
    }
    //fin arbol

    public String editarCuenta() {
        tipoAplicableAntiguo = cuentaIngresoSeleccionado.getAplicable().ordinal();
        cuentaIngreso = cuentaIngresoSeleccionado;
        cuentaIngresoElectoral = new CuentaIngresoElectoral();
        cuentaingresoAmbiente = new CuentaingresoAmbiente();
        cuentaingresoEvento = new CuentaingresoEvento();
        cuentaingresoServicio = new CuentaingresoServicio();
        nombreCuentaContable = cuentaIngresoSeleccionado.getFkCcoCodigo().getNombreLargo();
        if (cuentaIngresoSeleccionado.getTipo().equals(EnumTipoCuentaIngreso.Evento)) {
            cuentaingresoEvento.setFkEveCodigo(cuentaIngresoSeleccionado.getCuentaingresoEvento().getFkEveCodigo());
            tipoCuentaEditar = "Evento";
        } else {
            if (cuentaIngresoSeleccionado.getTipo().equals(EnumTipoCuentaIngreso.Ambiente)) {
                cuentaingresoAmbiente.setFkAmbCodigo(cuentaIngresoSeleccionado.getCuentaingresoAmbiente().getFkAmbCodigo());
                tipoCuentaEditar = "Ambiente";
            } else {
                if (cuentaIngresoSeleccionado.getTipo().equals(EnumTipoCuentaIngreso.Servicio)) {
                    cuentaingresoServicio.setFkSerCodigo(cuentaIngresoSeleccionado.getCuentaingresoServicio().getFkSerCodigo());
                    tipoCuentaEditar = "Servicio";
                } else {
                    if (cuentaIngresoSeleccionado.getTipo().equals(EnumTipoCuentaIngreso.Elecciones)) {
                        cuentaIngresoElectoral.setProcesoElectoral(cuentaIngresoSeleccionado.getCuentaIngresoElectoral().getProcesoElectoral());
                        cuentaIngresoElectoral.setMultaAplicadaA(cuentaIngresoSeleccionado.getCuentaIngresoElectoral().getMultaAplicadaA());
                        tipoCuentaEditar = "Electoral";
                    }
                }
            }
        }
        return "editar";
    }

    public String nuevoPadre() {
        padreHijo = 0;
        cuentaIngreso = new CuentaIngreso();
        cuentaIngreso.setAplicable(EnumAplicableCI.NINGUNO);
        cuentaIngreso.setEstado(EnumEstadoCuentaIngreso.ACTIVO);
        cuentaIngreso.setAfectoDescuentoPagoAnual(false);
        cuentaIngresoElectoral = new CuentaIngresoElectoral();
        cuentaingresoAmbiente = new CuentaingresoAmbiente();
        cuentaingresoEvento = new CuentaingresoEvento();
        cuentaingresoServicio = new CuentaingresoServicio();
        nombreCuentaContable = null;
        return "nuevo";
    }

    public String nuevoHijo() {
        padreHijo = 1;
        cuentaIngreso = new CuentaIngreso();
        cuentaIngreso.setAplicable(EnumAplicableCI.NINGUNO);
        cuentaIngreso.setEstado(EnumEstadoCuentaIngreso.ACTIVO);
        cuentaIngreso.setAfectoDescuentoPagoAnual(false);
        cuentaIngresoElectoral = new CuentaIngresoElectoral();
        cuentaingresoAmbiente = new CuentaingresoAmbiente();
        cuentaingresoEvento = new CuentaingresoEvento();
        cuentaingresoServicio = new CuentaingresoServicio();
        nombreCuentaContable = null;
        return "nuevo";
    }

    public String eliminar() {
        try {
            cuentaIngresoSeleccionado.setEstado(EnumEstadoCuentaIngreso.ANULADO);
            delegado.edit(cuentaIngresoSeleccionado);
            actualizar = true;
        } catch (Exception ex) {
            return null;
        }
        return null;
    }

    public String activarCuentas() {
        try {
            cuentaIngresoSeleccionado.setEstado(EnumEstadoCuentaIngreso.ACTIVO);
            delegado.edit(cuentaIngresoSeleccionado);
            actualizar = true;
            paginador.reset();
        } catch (Exception ex) {
            System.out.println("Error:" + ex.getMessage());
            return "buscar";
        }
        return "buscar";
    }

    public String buscarCuentasAnuladas() {
        try {
            paginador.reset();
        } catch (Exception ex) {
            return null;
        }
        return null;
    }

    public String cancelarEliminar() {
        return null;
    }

    public String guardarCuentaIngreso() {
        try {
            actualizar = true;
            if (padreHijo == 0) {
                cuentaIngreso.setFkCinCodigoPadre(null);
            }
            if (padreHijo == 1) {
                if (cuentaIngresoSeleccionado != null) {
                    cuentaIngreso.setFkCinCodigoPadre(cuentaIngresoSeleccionado);
                }
            }
            if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Elecciones)){
                cuentaIngreso.setAfectoDescuentoPagoAnual(true);
            }
            delegado.create(cuentaIngreso);
            if (padreHijo == 1) {
                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Evento)) {
                    //lizardo estuvo aqui
                    Evento evento = new Evento();
                    EventoDelegate delegadoEve = new EventoDelegate();
                    eveCodigo = (eveCodigo != null) ? eveCodigo : 0;
                    evento = delegadoEve.find(eveCodigo);
                    if (evento != null) {
                        cuentaingresoEvento.setFkEveCodigo(evento);
                    } else {
                        ControladorAbstracto.error("Sucedió un error al insertar");
                        return null;
                    }
                    evento = null;
                    delegadoEve = null;
                    //fin de lizardo estuvo aqui
                    cuentaingresoEvento.setCuentaIngreso(cuentaIngreso);
                    delegadoEvento.create(cuentaingresoEvento);
                    cuentaIngreso.setCuentaingresoEvento(cuentaingresoEvento);
                }
                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Ambiente)) {
                    cuentaingresoAmbiente.setCinCodigo(cuentaIngreso.getCinCodigo());
                    cuentaingresoAmbiente.setCuentaIngreso(cuentaIngreso);
                    delegadoAmbiente.create(cuentaingresoAmbiente);
                    cuentaIngreso.setCuentaingresoAmbiente(cuentaingresoAmbiente);
                }
                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Servicio)) {
                    cuentaingresoServicio.setCinCodigo(cuentaIngreso.getCinCodigo());
                    cuentaingresoServicio.setCuentaIngreso(cuentaIngreso);
                    delegadoServicio.create(cuentaingresoServicio);
                    cuentaIngreso.setCuentaingresoServicio(cuentaingresoServicio);
                }

                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Elecciones)) {
                    cuentaIngresoElectoral.setCinCodigo(cuentaIngreso.getCinCodigo());
                    cuentaIngresoElectoral.setCuentaIngreso(cuentaIngreso);
                    delegadoProcesoElectoral.create(cuentaIngresoElectoral);
                    cuentaIngreso.setCuentaIngresoElectoral(cuentaIngresoElectoral);
                }
                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Cuota_CIP)) {
                    CuentaingresoOrdinariovitalicio ciov = new CuentaingresoOrdinariovitalicio();
                    ciov.setAplicable(cuentaIngreso.getAplicable());
                    ciov.setCovFechinicio(fechaInicio);
                    ciov.setFkCinCodigo(cuentaIngreso);
                    delegadoCuentaIngresoOrdinarioVitalicio.create(ciov);
                    CuentaingresoOrdinariovitalicio ciovAux = delegadoCuentaIngresoOrdinarioVitalicio.cuentaIngresoOrdVitAnterior(cuentaIngreso.getCinCodigo());
                    if (ciovAux != null) {
                        Calendar cal = Calendar.getInstance();
                        cal.setTime(fechaInicio);
                        cal.add(Calendar.DAY_OF_MONTH, -1);
                        ciovAux.setCovFechfin(cal.getTime());
                        delegadoCuentaIngresoOrdinarioVitalicio.edit(ciovAux);
                    }

                }
            }            
            cuentaIngresoSeleccionado = cuentaIngreso;
            ControladorAbstracto.info("Se insertó satisfactoriamente");
            return "buscar";
        } catch (Exception ex) {
            ControladorAbstracto.error("Sucedió un error al insertar");
            return null;
        }
    }

    public String cancelarCuentaIngreso() {
        return "cancelar";
    }

    private void eliminarCuentaRelacionada() {
        if (tipoCuentaEditar.equals("Evento")) {
            delegadoEvento.remove(cuentaIngreso.getCuentaingresoEvento());
            cuentaIngreso.setCuentaingresoEvento(null);
        }
        if (tipoCuentaEditar.equals("Ambiente")) {
            delegadoAmbiente.remove(cuentaIngreso.getCuentaingresoAmbiente());
            cuentaIngreso.setCuentaingresoAmbiente(null);
        }
        if (tipoCuentaEditar.equals("Servicio")) {
            delegadoServicio.remove(cuentaIngreso.getCuentaingresoServicio());
            cuentaIngreso.setCuentaingresoServicio(null);
        }

        if (tipoCuentaEditar.equals("Electoral")) {
            delegadoProcesoElectoral.remove(cuentaIngreso.getCuentaIngresoElectoral());
            cuentaIngreso.setCuentaIngresoElectoral(null);
        }

    }

    public String actualizarCuentaIngreso() {
        try {
            actualizar = true;
            if (tipoAplicableAntiguo != cuentaIngreso.getAplicable().ordinal()) {
                CuentaingresoOrdinariovitalicio ciova = delegadoCuentaIngresoOrdinarioVitalicio.cuentaIngresoOrdVitAnterior(cuentaIngreso.getCinCodigo());
                if (ciova != null) {
                    if(fechaInicio!=null){
                        if (fechaInicio.compareTo(ciova.getCovFechinicio()) <= 0) {
                            ControladorAbstracto.warn("La fecha de inicio no puede ser menor a la fecha Anterior");
                            return null;
                        }
                    }else{
                        ControladorAbstracto.error("Debe ingresar la fecha de inicio");
                        return null;
                    }
                }
            }
            delegado.edit(cuentaIngreso);
            if (cuentaIngreso.getFkCinCodigoPadre() != null) {
                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Evento)) {
                    if (!tipoCuentaEditar.equals("Evento")) {
                        eliminarCuentaRelacionada();
                        cuentaingresoEvento.setCinCodigo(cuentaIngreso.getCinCodigo());
                        cuentaingresoEvento.setCuentaIngreso(cuentaIngreso);
                        delegadoEvento.create(cuentaingresoEvento);
                        cuentaIngreso.setCuentaingresoEvento(cuentaingresoEvento);
                    } else {
                        if (!cuentaIngreso.getCuentaingresoEvento().getFkEveCodigo().equals(cuentaingresoEvento.getFkEveCodigo())) {
                            eliminarCuentaRelacionada();
                            cuentaingresoEvento.setCinCodigo(cuentaIngreso.getCinCodigo());
                            cuentaingresoEvento.setCuentaIngreso(cuentaIngreso);
                            delegadoEvento.create(cuentaingresoEvento);
                            cuentaIngreso.setCuentaingresoEvento(cuentaingresoEvento);
                        }
                    }
                }
                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Ambiente)) {
                    if (!tipoCuentaEditar.equals("Ambiente")) {
                        eliminarCuentaRelacionada();
                        cuentaingresoAmbiente.setCinCodigo(cuentaIngreso.getCinCodigo());
                        cuentaingresoAmbiente.setCuentaIngreso(cuentaIngreso);
                        delegadoAmbiente.create(cuentaingresoAmbiente);

                        cuentaIngreso.setCuentaingresoAmbiente(cuentaingresoAmbiente);
                    } else {
                        if (!cuentaIngreso.getCuentaingresoAmbiente().getFkAmbCodigo().equals(cuentaingresoAmbiente.getFkAmbCodigo())) {
                            eliminarCuentaRelacionada();
//                    Ambiente ambiente = cuentaingresoAmbiente.getFkAmbCodigo();
//                    cuentaingresoAmbiente = new CuentaingresoAmbiente();
//                    cuentaingresoAmbiente.setFkAmbCodigo(ambiente);
                            cuentaingresoAmbiente.setCuentaIngreso(cuentaIngreso);
                            delegadoAmbiente.create(cuentaingresoAmbiente);
                            cuentaIngreso.setCuentaingresoAmbiente(cuentaingresoAmbiente);
                        }
                    }
                }
                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Servicio)) {
                    if (!tipoCuentaEditar.equals("Servicio")) {
                        eliminarCuentaRelacionada();
                        cuentaingresoServicio.setCinCodigo(cuentaIngreso.getCinCodigo());
                        cuentaingresoServicio.setCuentaIngreso(cuentaIngreso);
                        delegadoServicio.create(cuentaingresoServicio);
                        cuentaIngreso.setCuentaingresoServicio(cuentaingresoServicio);
                    } else {
                        if (!cuentaIngreso.getCuentaingresoServicio().getFkSerCodigo().equals(cuentaingresoServicio.getFkSerCodigo())) {
                            eliminarCuentaRelacionada();
                            cuentaingresoServicio.setCinCodigo(cuentaIngreso.getCinCodigo());
                            cuentaingresoServicio.setCuentaIngreso(cuentaIngreso);
                            delegadoServicio.create(cuentaingresoServicio);
                            cuentaIngreso.setCuentaingresoServicio(cuentaingresoServicio);
                        }
                    }
                }

                if (cuentaIngreso.getTipo().equals(EnumTipoCuentaIngreso.Elecciones)) {
                    if (!tipoCuentaEditar.equals("Electoral")) {
                        eliminarCuentaRelacionada();
                        cuentaIngresoElectoral.setCinCodigo(cuentaIngreso.getCinCodigo());
                        cuentaIngresoElectoral.setCuentaIngreso(cuentaIngreso);
                        delegadoProcesoElectoral.create(cuentaIngresoElectoral);
                        cuentaIngreso.setCuentaIngresoElectoral(cuentaIngresoElectoral);
                    } else {
                        if (!cuentaIngreso.getCuentaIngresoElectoral().getProcesoElectoral().equals(cuentaIngresoElectoral.getProcesoElectoral())) {
                            eliminarCuentaRelacionada();
                            cuentaIngresoElectoral.setCinCodigo(cuentaIngreso.getCinCodigo());
                            cuentaIngresoElectoral.setCuentaIngreso(cuentaIngreso);
                            delegadoProcesoElectoral.create(cuentaIngresoElectoral);
                            cuentaIngreso.setCuentaIngresoElectoral(cuentaIngresoElectoral);
                        }
                    }
                }
                delegado.edit(cuentaIngreso);
            }
            if (tipoAplicableAntiguo != cuentaIngreso.getAplicable().ordinal()) {
                CuentaingresoOrdinariovitalicio ciova = delegadoCuentaIngresoOrdinarioVitalicio.cuentaIngresoOrdVitAnterior(cuentaIngreso.getCinCodigo());
                if (ciova != null) {
                    Calendar cal = Calendar.getInstance();
                    cal.setTime(fechaInicio);
                    cal.add(Calendar.DAY_OF_MONTH, -1);
                    ciova.setCovFechfin(cal.getTime());
                    delegadoCuentaIngresoOrdinarioVitalicio.edit(ciova);
                }
                CuentaingresoOrdinariovitalicio ciov = new CuentaingresoOrdinariovitalicio();
                ciov.setAplicable(cuentaIngreso.getAplicable());
                ciov.setCovFechinicio(fechaInicio);
                ciov.setFkCinCodigo(cuentaIngreso);
                delegadoCuentaIngresoOrdinarioVitalicio.create(ciov);
            }
            cuentaIngresoSeleccionado = cuentaIngreso;
            ControladorAbstracto.info("Se actualizó satisfactoriamente");
            return "buscar";
        } catch (Exception ex) {
            ControladorAbstracto.error("Sucedió un error al actualizar");
            return null;
        }
    }

    public List<CuentaIngreso> autocompletarCuentasIngreso(Object event) {
        List<CuentaIngreso> lista = new ArrayList();
        String codi = event.toString().toUpperCase();
        try {
            lista = delegado.listaCuentasIngresoPorCodigo(codi);
        } catch (Exception ex) {
            ex.toString();
        }
        return lista;
    }

    //creado x Ingrid para pagos varios - tipo cuenta ingreso: otros
    public List<CuentaIngreso> autocompletarCuentasIngresoPagosVarios(Object event) {
        List<CuentaIngreso> listaPV = new ArrayList();
        String codi = event.toString().toUpperCase();
        try {
            listaPV = delegado.listaCuentasIngresoPagosVariosPorCodigo(codi);
        } catch (Exception ex) {
            ex.toString();
        }
        return listaPV;
    }

    public SelectItem[] getEnumAplicableCIItems() {
        try {
            SelectItem[] select = new SelectItem[EnumAplicableCI.values().length];
            int i = 0;
            for (EnumAplicableCI en : EnumAplicableCI.values()) {
                SelectItem item = new SelectItem(en, en.name());
                select[i++] = item;
            }

            return select;
        } catch (Exception ex) {
            SelectItem[] select = new SelectItem[1];
            SelectItem item = new SelectItem(null, "No existe Enum Aplicable");
            select[0] = item;
            return select;
        }
    }    

    public SelectItem[] getEnumTipoExoneracionesItems() {
        try {
            SelectItem[] select = new SelectItem[EnumTipoDescuento.values().length];
            int i = 0;
            for (EnumTipoDescuento en : EnumTipoDescuento.values()) {
                SelectItem item = new SelectItem(en, en.name());
                select[i++] = item;
            }

            return select;
        } catch (Exception ex) {
            SelectItem[] select = new SelectItem[1];
            SelectItem item = new SelectItem(null, "No existe Enum Aplicable");
            select[0] = item;
            return select;
        }
    }

    public SelectItem[] getEnumTipoCuentaIngresoItems() {
        try {
            SelectItem[] select = new SelectItem[EnumTipoCuentaIngreso.values().length];
            int i = 0;
            for (EnumTipoCuentaIngreso en : EnumTipoCuentaIngreso.values()) {
                SelectItem item = new SelectItem(en, en.name());
                select[i++] = item;
            }

            return select;
        } catch (Exception ex) {
            SelectItem[] select = new SelectItem[1];
            SelectItem item = new SelectItem(null, "No existen Tipos Cuenta de Ingreso");
            select[0] = item;
            return select;
        }
    }

    public String nuevaCuentaContable() {
        CuentaContableController cucoc = (CuentaContableController) getBean("cuentaContable");
        cucoc.setControladorSolicitante(1); /*llama el Controlador de CuentaIngresoController*/
        cucoc.setCuentaContable(new CuentaContable());
        return "nuevaCuentaContable";
    }

    /**
     * @return the nombreCuentaContable
     */
    public String getNombreCuentaContable() {
        return nombreCuentaContable;
    }

    /**
     * @param nombreCuentaContable the nombreCuentaContable to set
     */
    public void setNombreCuentaContable(String nombreCuentaContable) {
        this.nombreCuentaContable = nombreCuentaContable;
    }

    /**
     * @return the cuentaIngresoSeleccionado
     */
    public CuentaIngreso getCuentaIngresoSeleccionado() {
        return cuentaIngresoSeleccionado;
    }

    /**
     * @param cuentaIngresoSeleccionado the cuentaIngresoSeleccionado to set
     */
    public void setCuentaIngresoSeleccionado(CuentaIngreso cuentaIngresoSeleccionado) {
        this.cuentaIngresoSeleccionado = cuentaIngresoSeleccionado;
    }
}
